package com.kl.drs.util;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TimeZone;

import javassist.expr.NewArray;

import org.apache.commons.lang.StringUtils;


/**
 * 日期时间操作定义类
 * 
 * @author Administrator
 * @Date 2016-10-24
 * 
 */
public class DateUtils {
	// 各种时间格式
	public static final String  date_sdf = "yyyy-MM-dd";
	public static final String  yyyyMMdd = "yyyyMMdd";
	public static final String date_sdf_wz = "yyyy年MM月dd日";
	public static final String time_sdf = "yyyy-MM-dd HH:mm";
	public static final String date_sdf_inclined = "yyyy/MM/dd HH:mm:ss";
	public static final String yyyymmddhhmmss = "yyyyMMddHHmmss";
	public static final String short_time_sdf = "HH:mm";
	public static final String hhmmss = "HH:mm:ss";
	public static final String datetimeFormat = "yyyy-MM-dd HH:mm:ss";

	// 以毫秒表示的时间
	private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
	private static final long HOUR_IN_MILLIS = 3600 * 1000;
	private static final long MINUTE_IN_MILLIS = 60 * 1000;
	private static final long SECOND_IN_MILLIS = 1000;

	
	/** 
	 * 获取更改时区后的日期 
	 * @param date 日期 
	 * @param oldZone 旧时区对象 
	 * @param newZone 新时区对象 
	 * @return 日期 
	 */  
	public static Date changeTimeZone(Date date) {  
	    Date dateTmp = null; 
	    if (date != null) {  
	        
	        TimeZone.setDefault(TimeZone.getTimeZone("GMT+8"));
	        dateTmp = new Date(date.getTime());
	    }  
	    return dateTmp;  
	}  
	
	
	// 指定模式的时间格式
	private static SimpleDateFormat getSDFormat(String pattern) {
		return new SimpleDateFormat(pattern);
	}

	/**
	 * 当前日历，这里用中国时间表示
	 * 
	 * @return 以当地时区表示的系统当前日历
	 */
	public static Calendar getCalendar() {
		return Calendar.getInstance();
	}

	/**
     * 获取当前时间 yyyy-MM-dd
     *
     * @return String
     */
    public static String getCurrTimeDay() {
        Date now = new Date(); 
        now = changeTimeZone(now);
        SimpleDateFormat date_sdf1 = new SimpleDateFormat(date_sdf);
        String s = date_sdf1.format(now);
        return s;
    }
    
    /**
     * 获取当前时间 yyyy-MM-dd + N年
     *
     * @return String
     */
    public static String getCurrDayAddYears(String currDay, int addYears) {
    	String result = "";
        try {
	    	SimpleDateFormat sdf = new SimpleDateFormat(date_sdf);
	        Calendar cal = Calendar.getInstance();
			cal.setTime(sdf.parse(currDay));
	        cal.add(Calendar.YEAR, addYears);
	        Date now = cal.getTime();
	        now = changeTimeZone(now);
	        result = sdf.format(now);
		} catch (ParseException e) {
			e.printStackTrace();
		}
        return result;
    }
    
    /**
     * 获取当前时间 yyyy-MM-dd +1
     *
     * @return String
     */
    public static String getCurrTimeDayAndOne(String currDay) {
    	String result = "";
    	try {
	        SimpleDateFormat date_sdf1 = new SimpleDateFormat(date_sdf);
	        Calendar cal = Calendar.getInstance();
	        cal.setTime(parseStringToDate(currDay));
	        cal.add(Calendar.DATE, 1);
	        Date date = cal.getTime();
	        date = changeTimeZone(date);
	        result = date_sdf1.format(date);
    	} catch (ParseException e) {
    		e.printStackTrace();
    	}
        return result;
    }
    
    /**
     *  yyyy-MM-dd -1
     *
     * @return String
     */
    public static String getDaySubOne(String Day) {
    	if(Day==null)
    		return null;
    	SimpleDateFormat dateFormat = new SimpleDateFormat(date_sdf);
    	 Date dateStr = null;
         try {
        	 dateStr = parseStringToDate(Day);
//         System.out.println(dateStr.toLocaleString().split(" ")[0]);//切割掉不要的时分秒数据
         } catch (ParseException e) {
             e.printStackTrace();
         }
        Calendar date = Calendar.getInstance();
        date.setTime(dateStr);
        date.set(Calendar.DATE, date.get(Calendar.DATE) - 1);
        Date endDate = null;
		try {
			endDate = dateFormat.parse(dateFormat.format(date.getTime()));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        String s = dateFormat.format(endDate);
        return s;
    }
    
    /**
     * 获取当前时间 yyyyMMdd
     *
     * @return String
     */
    public static String getCurrTime() {
    	Date now = new Date(); 
    	now = changeTimeZone(now);
    	SimpleDateFormat yyyymmddhhmmss = new SimpleDateFormat("yyyyMMddHHmmss");
    	String s = yyyymmddhhmmss.format(now);
    	return s;
    }

	/**
	 * 指定毫秒数表示的日历
	 * 
	 * @param millis
	 *            毫秒数
	 * @return 指定毫秒数表示的日历
	 */
	public static Calendar getCalendar(long millis) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(changeTimeZone(new Date(millis)));
		return cal;
	}

	// ////////////////////////////////////////////////////////////////////////////
	// TODO:各种方式获取的Date
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 当前日期
	 * 
	 * @return 系统当前时间
	 */
	public static Date getDate() {
		return changeTimeZone(new Date());
	}

	/**
	 * 指定毫秒数表示的日期
	 * 
	 * @param millis
	 *            毫秒数
	 * @return 指定毫秒数表示的日期
	 */
	public static Date getDate(long millis) {
		return changeTimeZone(new Date(millis));
	}

	// ////////////////////////////////////////////////////////////////////////////
	// TODO：时间戳、日期、字符串相互转换
	// ////////////////////////////////////////////////////////////////////////////
	/**
	 * 时间戳转字符串
	 * @param time 时间戳
	 * @param pattern 时间格式
	 * @return 
	 * String
	 */
	public static String timestamptoStr(Timestamp time,String pattern) {
		SimpleDateFormat date_sdf = new SimpleDateFormat(pattern);
		Date date = null;
		if (null != time) {
			date = changeTimeZone(new Date(time.getTime()));
		}
		return date2Str(date,date_sdf);
	}

	/**
	 * 字符串转时间戳
	 * @param str  字符串
	 * @param pattern 时间格式
	 * @return 
	 * 		 Timestamp
	 */
	public static Timestamp str2Timestamp(String str,String pattern) {
		Date date = str2Date(str, pattern);
		return new Timestamp(date.getTime());
	}

	/**
	 * 字符串转换成日期
	 * 
	 * @param str 日期字符串
	 * @param sdf 与日期格式对应的格式对象
	 * @return
	 */
	public static Date str2Date(String str, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		if (null == str || "".equals(str)) {
			return null;
		}
		Date date = null;
		try {
			date = sdf.parse(str);
			date = changeTimeZone(date);
			return date;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}
	

	/**
	 * 当前日期转换为字符串
	 * @param date 日期
	 * @param format 日期格式对象
	 * @return 字符串
	 */
	public static String date2Str(SimpleDateFormat date_sdf) {
		Date date = getDate();
		if (null == date) {
			return null;
		}
		return date_sdf.format(date);
	}


	/**
	 * 日期转换为字符串
	 * 
	 * @param date
	 *            日期
	 * @param format
	 *            日期格式
	 * @return 字符串
	 */
	public static String date2Str(Date date, SimpleDateFormat date_sdf) {
		if (null == date) {
			return null;
		}
		date=changeTimeZone(date);
		return date_sdf.format(date);
	}
	/**
	 * 日期转换为字符串
	 * 
	 * @param date
	 *            日期
	 * @param format
	 *            日期格式
	 * @return 字符串
	 */
	public static String date2Str(Date date, String pattern) {
		if (null == date) {
			return null;
		}
		date=changeTimeZone(date);
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}

	/**
	 * 日期转换为字符串
	 * 
	 * @param date
	 *            日期
	 * @param pattern
	 *            日期格式
	 * @return 字符串
	 */
	public static String getDate(String pattern) {
		Date date = new Date();
		date = changeTimeZone(date);
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}

	/**
	 * 指定毫秒数的时间戳
	 * 
	 * @param millis
	 *            毫秒数
	 * @return 指定毫秒数的时间戳
	 */
	public static Timestamp getTimestamp(long millis) {
		return new Timestamp(millis);
	}

	/**
	 * 以字符形式表示的时间戳
	 * 
	 * @param time
	 *            毫秒数
	 * @return 以字符形式表示的时间戳
	 */
	public static Timestamp getTimestamp(String time) {
		return new Timestamp(Long.parseLong(time));
	}

	/**
	 * 系统当前的时间戳
	 * 
	 * @return 系统当前的时间戳
	 */
	public static Timestamp getTimestamp() {
		return new Timestamp(changeTimeZone(new Date()).getTime());
	}

	/**
	 * 指定日期的时间戳
	 * 
	 * @param date
	 *            指定日期
	 * @return 指定日期的时间戳
	 */
	public static Timestamp getTimestamp(Date date) {
		date=changeTimeZone(date);
		return new Timestamp(date.getTime());
	}

	/**
	 * 指定日历的时间戳
	 * 
	 * @param cal
	 *            指定日历
	 * @return 指定日历的时间戳
	 */
	public static Timestamp getCalendarTimestamp(Calendar cal) {
		return new Timestamp(cal.getTime().getTime());
	}
	
	// ////////////////////////////////////////////////////////////////////////////
	// TODO:各种方式获取的Millis
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 系统时间的毫秒数
	 * 
	 * @return 系统时间的毫秒数
	 */
	public static long getMillis() {
		return changeTimeZone(new Date()).getTime();
	}

	/**
	 * 指定日历的毫秒数
	 * 
	 * @param cal
	 *            指定日历
	 * @return 指定日历的毫秒数
	 */
	public static long getMillis(Calendar cal) {
		return cal.getTime().getTime();
	}

	/**
	 * 指定日期的毫秒数
	 * 
	 * @param date
	 *            指定日期
	 * @return 指定日期的毫秒数
	 */
	public static long getMillis(Date date) {
		date=changeTimeZone(date);
		return date.getTime();
	}

	/**
	 * 指定时间戳的毫秒数
	 * 
	 * @param ts
	 *            指定时间戳
	 * @return 指定时间戳的毫秒数
	 */
	public static long getMillis(Timestamp ts) {
		return ts.getTime();
	}

	// ////////////////////////////////////////////////////////////////////////////
	// formatDate
	// TODO:将日期|日历|毫秒按照一定的格式转化为字符串
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 获取时间字符串
	 * @param formatstr 日期格式对象
	 * @return
	 */
	public static String getDataString(SimpleDateFormat formatstr) {
		return formatstr.format(getCalendar().getTime());
	}

	/**
	 * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
	 * 
	 * @param millis
	 *            指定的毫秒数
	 * @return 指定毫秒数表示日期按“年-月-日“格式显示
	 */
	public static String formatDate(long millis,String pattern) {
		SimpleDateFormat date_sdf = new SimpleDateFormat(pattern);
		return date_sdf.format(changeTimeZone(new Date(millis)));
	}

	/**
	 * 默认日期按指定格式显示
	 * 
	 * @param pattern
	 *            指定的格式
	 * @return 默认日期按指定格式显示
	 */
	public static String formatDate(String pattern) {
		return getSDFormat(pattern).format(getCalendar().getTime());
	}
	/**
	 * 默认时间按照指定时间输出显示
	 */
	public static String formatToDate(String pattern){
		SimpleDateFormat formater=new SimpleDateFormat(pattern);
		//String strCurrentTime=formater.format(new Date());
		return formater.format(new Date());
	}
	/**
	 * 系统时间的前一天按指定格式显示
	 * 
	 * @param pattern
	 *            指定的格式
	 * @return 默认日期按指定格式显示
	 */
	public static String beforeDayFormatDate(String pattern) {
		Date date = new Date();
		date=changeTimeZone(date);
		Calendar calendar = getCalendar();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		return getSDFormat(pattern).format(calendar.getTime());
	}
   
	/**
	 * 指定日期按指定格式显示
	 * 
	 * @param cal
	 *            指定的日期
	 * @param pattern
	 *            指定的格式
	 * @return 指定日期按指定格式显示
	 * @throws ParseException 
	 */
	public static String beforeDayformatDate(String str, String pattern) throws ParseException {
		Calendar cal = parseCalendar(str,pattern);
		cal.add(Calendar.DAY_OF_MONTH, -1);
		return getSDFormat(pattern).format(cal.getTime());
	}
	/**
	 * 指定日期按指定格式显示
	 * 
	 * @param cal
	 *            指定的日期
	 * @param pattern
	 *            指定的格式
	 * @return 指定日期按指定格式显示
	 */
	public static String formatDate(Calendar cal, String pattern) {
		return getSDFormat(pattern).format(cal.getTime());
	}

	/**
	 * 指定日期按指定格式显示
	 * 
	 * @param date
	 *            指定的日期
	 * @param pattern
	 *            指定的格式
	 * @return 指定日期按指定格式显示
	 */
	public static String formatDate(Date date, String pattern) {
		date=changeTimeZone(date);
		return getSDFormat(pattern).format(date);
	}

	// ////////////////////////////////////////////////////////////////////////////
	// formatTime
	// 将日期按照一定的格式转化为字符串
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 默认方式表示的系统当前日期
	 * 
	 *@param pattern
	 *            日期格式
	 * @return 默认日期按“日期格式“格式显示
	 */
	public static String formatTime(String pattern) {
		SimpleDateFormat time_sdf = new SimpleDateFormat(pattern);
		return time_sdf.format(getCalendar().getTime());
	}

	/**
	 * 指定日期的默认显示
	 * 
	 * @param cal
	 *            指定的日期
	 * @param pattern
	 *            日期格式           
	 * @return 指定日期按“日期格式“格式显示
	 */
	public static String formatTime(Calendar cal,String pattern) {
		SimpleDateFormat time_sdf = new SimpleDateFormat(pattern);
		return time_sdf.format(cal.getTime());
	}

	/**
	 * 指定日期的默认显示
	 * 
	 * @param date
	 *            指定的日期
	 * @param pattern
	 *            日期格式            
	 * @return 指定日期按“日期格式“格式显示
	 */
	public static String formatTime(Date date,String pattern) {
		SimpleDateFormat time_sdf = new SimpleDateFormat(pattern);
		date=changeTimeZone(date);
		return time_sdf.format(date);
	}

	// ////////////////////////////////////////////////////////////////////////////
	// parseDate
	// parseCalendar
	// parseTimestamp
	// 将字符串按照一定的格式转化为日期或时间
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 * @param src
	 *            将要转换的原始字符窜
	 * @param pattern
	 *            转换的匹配格式
	 * @return 如果转换成功则返回转换后的日期
	 * @throws ParseException
	 * @throws AIDateFormatException
	 */
	public static Date parseDate(String src, String pattern)throws ParseException {
		return changeTimeZone(getSDFormat(pattern).parse(src));
	}

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 * 
	 * @param src
	 *            将要转换的原始字符窜
	 * @param pattern
	 *            转换的匹配格式
	 * @return 如果转换成功则返回转换后的日期
	 * @throws ParseException
	 * @throws AIDateFormatException
	 */
	public static Calendar parseCalendar(String src, String pattern) throws ParseException {
		Date date = parseDate(src, pattern);
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal;
	}
	
	/**
	 * 根据指定的格式将字符串转换成Date
	 * @param src  将要转换的原始字符窜
	 * @param pattern  转换的匹配格式
	 * @param amount 天数
	 * @return
	 * @throws ParseException
	 */
	public static String formatAddDate(String src, String pattern, int amount)
			throws ParseException {
		Calendar cal;
		cal = parseCalendar(src, pattern);
		cal.add(Calendar.DATE, amount);
		return formatTime(cal,pattern);
	}

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 * 
	 * @param src
	 *            将要转换的原始字符窜
	 * @param pattern
	 *            转换的匹配格式
	 * @return 如果转换成功则返回转换后的时间戳
	 * @throws ParseException
	 * @throws AIDateFormatException
	 */
	public static Timestamp parseTimestamp(String src, String pattern) throws ParseException {
		Date date = parseDate(src, pattern);
		return new Timestamp(date.getTime());
	}

	// ////////////////////////////////////////////////////////////////////////////
	// dateDiff
	// 计算两个日期之间的差值
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 计算两个时间之间的差值，根据标志的不同而不同
	 * 
	 * @param flag y/d/h/m/s
	 *            计算标志，表示按照年/月/日/时/分/秒等计算
	 * @param calSrc
	 *            减数
	 * @param calDes
	 *            被减数
	 * @return 两个日期之间的差值
	 */
	public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {

		long millisDiff = getMillis(calSrc) - getMillis(calDes);

		if (flag == 'y') {
			return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
		}

		if (flag == 'd') {
			return (int) (millisDiff / DAY_IN_MILLIS);
		}

		if (flag == 'h') {
			return (int) (millisDiff / HOUR_IN_MILLIS);
		}

		if (flag == 'm') {
			return (int) (millisDiff / MINUTE_IN_MILLIS);
		}

		if (flag == 's') {
			return (int) (millisDiff / SECOND_IN_MILLIS);
		}

		return 0;
	}

	/**
	 * 当前日期年份
	 * @return
	 */
	public static int getYear() {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(getDate());
		return calendar.get(Calendar.YEAR);
	}
	
	/**
	 * 秒级单位
	 * @param millis
	 * @return
	 */
	public static long getDateTime(long millis){
		return millis/1000;
	}
	/**
	 * 日期时间
	 * @param 日期
	 * @return
	 * @throws ParseException 
	 */
	public static long getDateTime() throws ParseException{
		Date dt=new Date();
		dt=changeTimeZone(dt);
		SimpleDateFormat matter1=new SimpleDateFormat("yyyy-MM-dd");
		return getTimeByLongSpit(matter1.format(dt));
	}
	
	/**
	 * 秒级单位
	 * @param millis
	 * @return String
	 */
	public static String getTimeStamp() {
        return String.valueOf(System.currentTimeMillis() / 1000);
    }
	
	/**
	 * 指定秒数表示日期的默认显示，具体格式：年/月/日 时:分
	 * @param secs
	 *            指定的秒数
	 * @return 指定毫秒数表示日期按“年/月/日 时:分“格式显示
	 */
	public static String formatInclinedDate(long secs) {
		SimpleDateFormat date_sdf_inclined = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		return date_sdf_inclined.format(changeTimeZone(new Date(secs*1000)));
	}
	
	/**
	 * 指定秒数表示日期的默认显示，具体格式：年/月/日 时:分
	 * @param secs
	 *            指定的秒数
	 * @return 指定毫秒数表示日期按“年/月/日 时:分“格式显示
	 */
	public static String formatCurrentDate(long secs) {
		SimpleDateFormat date_sdf_inclined = new SimpleDateFormat(time_sdf);
		return date_sdf_inclined.format(changeTimeZone(new Date(secs*1000)));
	}
	
	/**
	 * 字符串转化为标准日期格式字符串
	 * @param org  yyyyMMddHHmmss
	 * @return	   yyyy-MM-dd HH:mm:ss
	 * @throws ParseException 
	 */
	public static String formatToDateString(String org) throws ParseException {
		SimpleDateFormat dateFormat1 = new SimpleDateFormat(yyyymmddhhmmss);
		SimpleDateFormat dateFormat = new SimpleDateFormat(datetimeFormat);
		Date parse = dateFormat1.parse(org);
		String format = dateFormat.format(parse);
		return format;
	}
	/**
	 * 指定秒数表示日期的默认显示
	 * @param secs 指定的秒数
	 * @param pattern 日期格式
	 * @return
	 */
	public static String getDateByMillis(long secs, String pattern) {
		Date date = getDate(secs*1000);
		date=changeTimeZone(date);
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		return sdf.format(date);
	}
	
	public static long getCurrentTimeByLong()
	{
		return getDateTime(getDate().getTime());
	}
	
	public static long getTimeByLong(String dateStr) throws ParseException
	{
		return getDateTime(parseDate(dateStr,"yyyyMMdd").getTime());
	}
	
	public static long getTimeByLong(String dateStr, String timeStr) throws ParseException
	{
		return getDateTime(parseDate(dateStr+timeStr,"yyyyMMddHH:mm:ss").getTime());
	}
	
	public static long getTimeByLongSpit(String dateStr) throws ParseException
	{
		return getDateTime(parseDate(dateStr,"yyyy-MM-dd").getTime());
	}
	
	public static long getTimeByLongSec(String dateStr) throws ParseException
	{
		return getDateTime(parseDate(dateStr,"yyyy-MM-dd HH:mm:ss").getTime());
	}
	
	/**
	 * 获取从当前到指定月数的日期
	 * @param amount 把日期往后增：整数往后推,负数往前移动
	 * @param pattern 日期格式
	 * @return
	 */
	public static String getSpecMonth(int amount,String pattern){
		if(StringUtils.isBlank(pattern)){
			pattern = "yyyyMMdd";
		}
		Date date=new Date();//取时间
		date = changeTimeZone(date);
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(Calendar.MONTH, amount);//把日期往后增加一.整数往后推,负数往前移动
		date=calendar.getTime(); //这个时间就是日期往后推一天的结果
		SimpleDateFormat formatter = new SimpleDateFormat(pattern);
		return formatter.format(date);
	}
	
	public static String getNextDay()
	{
		Date date=new Date();//取时间
		date = changeTimeZone(date);
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(calendar.DATE,1);//把日期往后增加一天.整数往后推,负数往前移动
		date=calendar.getTime(); //这个时间就是日期往后推一天的结果
		SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
		return formatter.format(date);
	}
	
	public static String getMatuDate(String effDate, String insuYearFlag, String insuYear) throws ParseException
	{
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(DateUtils.parseDate(effDate, "yyyyMMdd"));
		if("D".equals(insuYearFlag))
		{
			calendar.add(calendar.DATE, Integer.valueOf(insuYear));
		}
		else if("M".equals(insuYearFlag))
		{
			calendar.add(calendar.MONTH, Integer.valueOf(insuYear));
		}
		else if("Y".equals(insuYearFlag))
		{
			calendar.add(calendar.YEAR, Integer.valueOf(insuYear));
		}
		
		return new SimpleDateFormat("yyyyMMdd").format(calendar.getTime());
	}
	
	public static String getMatuDate(long effDate, String insuYearFlag, String insuYear) throws ParseException
	{
		Calendar calendar = new GregorianCalendar();
		calendar.setTimeInMillis(effDate*1000);
		if("D".equals(insuYearFlag))
		{
			calendar.add(calendar.DATE, Integer.valueOf(insuYear));
		}
		else if("M".equals(insuYearFlag))
		{
			calendar.add(calendar.MONTH, Integer.valueOf(insuYear));
		}
		else if("Y".equals(insuYearFlag))
		{
			calendar.add(calendar.YEAR, Integer.valueOf(insuYear));
		}
		
		return new SimpleDateFormat("yyyyMMdd").format(calendar.getTime());
	}
	
	
	public static String formatMsgDate(long secs) {
		SimpleDateFormat date_sdf_inclined = new SimpleDateFormat("yyyy年MM月dd日");
		return date_sdf_inclined.format(changeTimeZone(new Date(secs*1000)));
	}
	/**
	 * 返回当前日期格式 yyyy-MM-dd
	 * @param secs
	 * @return
	 */
	public static String formatDateStr(long secs) {
		SimpleDateFormat date_sdf_inclined = new SimpleDateFormat(date_sdf);
		return date_sdf_inclined.format(changeTimeZone(new Date(secs*1000)));
	}
	
	
	public static String getYYYYMMDDFormat(String dateStr,String dateFormat) throws ParseException{
		
		return new SimpleDateFormat("yyyyMMdd").format(new SimpleDateFormat(dateFormat).parse(dateStr));
	}
	
	public static int getAge(Date pBirthday) {
		GregorianCalendar mBirthdayCalendar = new GregorianCalendar();
		mBirthdayCalendar.setTime(pBirthday);
		GregorianCalendar mNowCalendar = new GregorianCalendar();
		int mAge = mNowCalendar.get(Calendar.YEAR) - mBirthdayCalendar.get(Calendar.YEAR);
		mNowCalendar.add(Calendar.YEAR, -mAge);
		if (mNowCalendar.before(mBirthdayCalendar)) {
			mAge--;
		}
		return mAge;
	}
	
	public static Integer getAge(Date dateOfBirth, Date effectDate) {
		Integer age = 0;
		try {
			Calendar born = Calendar.getInstance();
			Calendar now = Calendar.getInstance();
			if (dateOfBirth != null) {
				now.setTime(effectDate);
				born.setTime(dateOfBirth);
				if (born.after(now)) {
					throw new IllegalArgumentException("年龄不能超过当前日期");
				}
				age = now.get(Calendar.YEAR) - born.get(Calendar.YEAR);
				int nowDayOfYear = now.get(Calendar.DAY_OF_YEAR);
				int bornDayOfYear = born.get(Calendar.DAY_OF_YEAR);
				// System.out.println("nowDayOfYear:" + nowDayOfYear + " bornDayOfYear:" + bornDayOfYear);
				if (nowDayOfYear < bornDayOfYear) {
					age -= 1;
				}
			}
		} catch (Exception e) {
			System.out.println("getAge Exception ============" + e);
		}
		return age;
	}
	
	public static Date getDateForAllForm(String dateStr) {
		try{
			return new SimpleDateFormat("yyyyMMdd").parse(dateStr);
		}catch(ParseException pe){
			try{
				return new SimpleDateFormat("yyyy-MM-dd").parse(dateStr);
			}catch(ParseException pe1){
				pe1.printStackTrace();
			}
		}
		return null;
	}
	
	public static Date parseStringToDate(String dateStr) throws ParseException {
		Date result = null;
		String parse = dateStr;
		try {
			if(dateStr==null || "".equals(dateStr)){
				return result;
			}
			parse = parse.replaceFirst("^[0-9]{4}([^0-9]?)", "yyyy$1");
			parse = parse.replaceFirst("^[0-9]{2}([^0-9]?)", "yy$1");
			parse = parse.replaceFirst("([^0-9]?)[0-9]{1,2}([^0-9]?)", "$1MM$2");
			parse = parse.replaceFirst("([^0-9]?)[0-9]{1,2}( ?)", "$1dd$2");
			parse = parse.replaceFirst("( )[0-9]{1,2}([^0-9]?)", "$1HH$2");
			parse = parse.replaceFirst("([^0-9]?)[0-9]{1,2}([^0-9]?)", "$1mm$2");
			parse = parse.replaceFirst("([^0-9]?)[0-9]{1,2}([^0-9]?)", "$1ss$2");
			SimpleDateFormat format = new SimpleDateFormat(parse);
			result = format.parse(dateStr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	public static String parseStrToStr(String dateStr, String pattern) throws ParseException{
		Date tmpDate = parseStringToDate(dateStr);
		if(tmpDate != null && !"".equals(tmpDate) && pattern != null && !"".equals(pattern)){
			return new SimpleDateFormat(pattern).format(tmpDate);
		}
		return null;
	}
	
	/**
	 * 通过时间秒毫秒数判断两个时间的间隔
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static int daysBetween(Date date1, Date date2) {
		int days = (int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24));
		return days;
	}
	
	public static void main(String[] args) throws ParseException {
//			 System.out.println("77778888".substring(0, 4));
//			 System.out.println(TimeZone.getDefault().getID());
////			 TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
//		     String in="431021199203057976";
//		     System.out.println(DateUtils.getDateTime(DateUtils.parseDate(in.substring(6, 14),"yyyyMMdd").getTime()));
//		     System.out.println(getCurrTimeDay());
//		     System.out.println(TimeZone.getDefault().getID());
//	         System.out.println(DateUtils.formatDate(699724800*1000,DateUtils.date_sdf));
//			 System.out.println(DateUtils.getDateByMillis(699724800, "yyyyMMdd"));
//	         System.out.println(getDateByMillis(314380800, date_sdf));
//			 System.out.println(beforeDayFormatDate(date_sdf));
//			 System.out.println(beforeDayformatDate("2017-09-15", date_sdf));
//			 System.out.println(getTimeByLongSpit("2017-09-15"));
//			 System.out.println(getTimeByLongSpit(beforeDayformatDate("2017-09-15", date_sdf)));
//			 System.out.println(getCurrTimeDay());
		
//			 System.out.println(getCurrDayAddYears("2017-08-26", 5));
//			 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//			 Date birthday = sdf.parse("1983-09-10");
			 System.out.println(DateUtils.formatToDate("yyyy-MM-dd HH:mm:ss"));
			 System.out.println(daysBetween(parseStringToDate("2016-12-32"), parseStringToDate("2017-01-01")));
		     Date birthday = DateUtils.parseStringToDate("19841012");
			 Date effDate = DateUtils.parseStringToDate("2016-12-18");
			 System.out.println(DateUtils.getAge(birthday, effDate));
//			 System.out.println(parseStringToDate("1990-02-18"));
//			 System.out.println(getAge(birthday));
//		     long time = 1501137220;
//		     System.out.println(formatDateStr(time));
//		     System.out.println(getDateByMillis(time,datetimeFormat));
//		     System.out.println(DateUtils.getDateTime(DateUtils.parseDate("2017-12-29 10:00:00",datetimeFormat).getTime()));
//		     System.out.println(getDate(yyyyMMdd));
//		     System.out.println(getDateByMillis(time,date_sdf));
//		     System.out.println(getDateByMillis(1484561118,date_sdf));
//		     System.out.println(formatMsgDate(1483943290));
//			 Date dt=new Date();
//			 SimpleDateFormat matter1=new SimpleDateFormat("yyyy-MM-dd");
//			 System.out.println(matter1.format(dt));
//			 Long date1= DateUtils.getTimeByLongSpit(matter1.format(dt));
//			 System.out.println(DateUtils.getTimeByLongSpit(matter1.format(dt)));
			 //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
            // String date = sdf.format(new Date()); 
//             try {
//				System.out.println(getMatuDate(333993600, "Y", "70"));
//			} catch (Exception e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
//            String date = sdf.format(timeStamp*1000);  
//            System.out.println(date);  
//			Date date = new Date();
//			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//			System.out.println(date);
//			System.out.println(DateUtils.getTimeByLongSpit("19810610"));
			
           
//            try {
//				System.out.println(getDateTime());
//				System.out.println(getDateByMillis(getDateTime(),"yyyyMMdd"));
//				System.out.println(getDateByMillis(getDateTime()+60*60*24*8,"yyyyMMdd"));
//            	System.out.println(getMatuDate(System.currentTimeMillis()/1000,DateTimeUnitCodeEnum.DAY,10));
//            	System.out.println(getMatuDate(System.currentTimeMillis()/1000,DateTimeUnitCodeEnum.DAY,11,"yyyy-MM-dd HH:mm:ss"));
//            	System.out.println(getMatuDate(1482940800,DateTimeUnitCodeEnum.DAY,10)-1);
//            	System.out.println(formatInclinedDate(getMatuDate(1482940800,DateTimeUnitCodeEnum.DAY,10)));
//            	System.out.println(formatInclinedDate(getMatuDate(1482940800,DateTimeUnitCodeEnum.DAY,10)-1));
//            	System.out.println(formatInclinedDate(getMatuDate(1482940800,DateTimeUnitCodeEnum.HOUR,16)));
//            	System.out.println(formatInclinedDate(getMatuDate(1482940800,DateTimeUnitCodeEnum.HOUR,16)-1));
//            	System.out.println(getMatuDate(1482940800,DateTimeUnitCodeEnum.DAY,10,"yyyy-MM-dd HH:mm:ss"));
//			} catch (Exception e) {
//				e.printStackTrace();
//			}
		     
		     /*
		     long begin = getTimeByLongSpit("2017-01-21"); 
		     long end = getTimeByLongSpit("2017-01-24");
		     int i = 0;
		     while(true){
		    	 String aa = getMatuDate(begin,DateTimeUnitCodeEnum.DAY,i,"yyyy-MM-dd");
		    	 System.out.println(aa);
		    	 if(aa.equals("2017-01-24"))
		    		 break;
		    	 else
		    		 i++;
		     }*/
//		     System.out.println(getMatuDate(begin,DateTimeUnitCodeEnum.DAY,1,"yyyy-MM-dd"));
	}
}
